/**
 * 翻译服务
 * 提供自动翻译功能，支持从中文自动生成其他语言翻译
 */

const logger = require('../utils/logger');

// 语言代码映射
const LOCALE_MAP = {
  'zh-CN': 'zh',      // 简体中文
  'zh-TW': 'zh-TW',   // 繁体中文
  'en-US': 'en',      // 英语
  'fr-FR': 'fr',      // 法语
  'ja-JP': 'ja',      // 日语
  'ko-KR': 'ko',      // 韩语
  'de-DE': 'de',      // 德语
  'es-ES': 'es',      // 西班牙语
  'ru-RU': 'ru',      // 俄语
  'pt-BR': 'pt',      // 葡萄牙语
};

/**
 * 使用百度翻译API进行翻译
 * 需要配置: process.env.BAIDU_TRANSLATE_APPID 和 process.env.BAIDU_TRANSLATE_SECRET
 */
async function translateWithBaidu(text, fromLang, toLang) {
  const appId = process.env.BAIDU_TRANSLATE_APPID;
  const secret = process.env.BAIDU_TRANSLATE_SECRET;
  
  if (!appId || !secret) {
    throw new Error('百度翻译API未配置');
  }
  
  try {
    const crypto = require('crypto');
    const salt = Date.now().toString();
    const query = text;
    const sign = crypto.createHash('md5').update(appId + query + salt + secret).digest('hex');
    
    const response = await fetch(
      `https://fanyi-api.baidu.com/api/trans/vip/translate?q=${encodeURIComponent(query)}&from=${fromLang}&to=${toLang}&appid=${appId}&salt=${salt}&sign=${sign}`,
      { method: 'GET' }
    );
    
    const result = await response.json();
    
    if (result.error_code) {
      throw new Error(`百度翻译API错误: ${result.error_msg}`);
    }
    
    return result.trans_result?.[0]?.dst || text;
  } catch (error) {
    logger.error('百度翻译失败', { error: error.message, text, fromLang, toLang });
    throw error;
  }
}

/**
 * 使用Google翻译API
 * 需要配置: process.env.GOOGLE_TRANSLATE_API_KEY
 */
async function translateWithGoogle(text, fromLang, toLang) {
  const apiKey = process.env.GOOGLE_TRANSLATE_API_KEY;
  
  if (!apiKey) {
    throw new Error('Google翻译API未配置');
  }
  
  try {
    const response = await fetch(
      `https://translation.googleapis.com/language/translate/v2?key=${apiKey}`,
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          q: text,
          source: fromLang,
          target: toLang,
          format: 'text'
        })
      }
    );
    
    const result = await response.json();
    
    if (result.error) {
      throw new Error(`Google翻译API错误: ${result.error.message}`);
    }
    
    return result.data?.translations?.[0]?.translatedText || text;
  } catch (error) {
    logger.error('Google翻译失败', { error: error.message, text, fromLang, toLang });
    throw error;
  }
}

/**
 * 简单的基于规则的翻译（作为fallback）
 * 仅提供一些常见词汇的映射
 */
function translateWithSimpleRules(text, toLang) {
  const simpleMap = {
    'en': {
      '首页': 'Home',
      '关于': 'About',
      '登录': 'Login',
      '注册': 'Register',
      '退出': 'Logout',
      '设置': 'Settings',
      '搜索': 'Search',
      '提交': 'Submit',
      '取消': 'Cancel',
      '确认': 'Confirm',
      '保存': 'Save',
      '删除': 'Delete',
      '编辑': 'Edit',
      '新增': 'Add',
      '加载中': 'Loading',
      '加载失败': 'Load failed',
    },
    'fr': {
      '首页': 'Accueil',
      '关于': 'À propos',
      '登录': 'Connexion',
      '注册': 'Inscription',
    },
    'ja': {
      '首页': 'ホーム',
      '关于': 'について',
      '登录': 'ログイン',
      '注册': '登録',
    },
    'zh-TW': {
      '首页': '首頁',
      '关于': '關於',
      '登录': '登錄',
      '注册': '註冊',
    }
  };
  
  const localeCode = LOCALE_MAP[toLang] || toLang;
  const map = simpleMap[localeCode] || {};
  return map[text] || text;
}

/**
 * 自动翻译文本到目标语言
 * @param {string} text - 源文本（通常是中文）
 * @param {string} fromLocale - 源语言代码 (如: 'zh-CN')
 * @param {string} toLocale - 目标语言代码 (如: 'en-US')
 * @returns {Promise<string>} 翻译后的文本
 */
async function translateText(text, fromLocale, toLocale) {
  if (!text || text.trim() === '') {
    return '';
  }
  
  // 如果源语言和目标语言相同，直接返回
  if (fromLocale === toLocale) {
    return text;
  }
  
  const fromLang = LOCALE_MAP[fromLocale] || fromLocale;
  const toLang = LOCALE_MAP[toLocale] || toLocale;
  
  // 优先使用配置的翻译API
  try {
    // 尝试使用百度翻译
    if (process.env.BAIDU_TRANSLATE_APPID) {
      return await translateWithBaidu(text, fromLang, toLang);
    }
    
    // 尝试使用Google翻译
    if (process.env.GOOGLE_TRANSLATE_API_KEY) {
      return await translateWithGoogle(text, fromLang, toLang);
    }
  } catch (error) {
    logger.warn('翻译API调用失败，使用简单规则翻译', { error: error.message });
  }
  
  // 如果没有配置API或API调用失败，使用简单规则
  return translateWithSimpleRules(text, toLocale);
}

/**
 * 批量翻译文本到多个目标语言
 * @param {string} text - 源文本
 * @param {string} fromLocale - 源语言代码
 * @param {string[]} targetLocales - 目标语言代码数组
 * @returns {Promise<Object>} 翻译结果对象 { 'en-US': '...', 'fr-FR': '...', ... }
 */
async function translateToMultipleLocales(text, fromLocale, targetLocales) {
  const results = {};
  
  // 并行翻译到所有目标语言
  const promises = targetLocales.map(async (locale) => {
    try {
      const translated = await translateText(text, fromLocale, locale);
      return { locale, translated };
    } catch (error) {
      logger.error(`翻译到${locale}失败`, { error: error.message });
      return { locale, translated: text }; // 失败时返回原文
    }
  });
  
  const resolved = await Promise.all(promises);
  resolved.forEach(({ locale, translated }) => {
    results[locale] = translated;
  });
  
  return results;
}

module.exports = {
  translateText,
  translateToMultipleLocales,
  LOCALE_MAP
};

